/*
 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

package java.awt.geom;

import java.awt.Shape;
import java.awt.Rectangle;
import java.io.Serializable;

/**
 * This <code>Line2D</code> represents a line segment in {@code (x,y)}
 * coordinate space.  This class, like all of the Java 2D API, uses a
 * default coordinate system called <i>user space</i> in which the y-axis
 * values increase downward and x-axis values increase to the right.  For
 * more information on the user space coordinate system, see the
 * <a href="https://docs.oracle.com/javase/1.3/docs/guide/2d/spec/j2d-intro.fm2.html#61857">
 * Coordinate Systems</a> section of the Java 2D Programmer's Guide.
 * <p>
 * This class is only the abstract superclass for all objects that
 * store a 2D line segment.
 * The actual storage representation of the coordinates is left to
 * the subclass.
 *
 * @author Jim Graham
 * @since 1.2
 */
public abstract class Line2D implements Shape, Cloneable {

  /**
   * A line segment specified with float coordinates.
   *
   * @since 1.2
   */
  public static class Float extends Line2D implements Serializable {

    /**
     * The X coordinate of the start point of the line segment.
     *
     * @serial
     * @since 1.2
     */
    public float x1;

    /**
     * The Y coordinate of the start point of the line segment.
     *
     * @serial
     * @since 1.2
     */
    public float y1;

    /**
     * The X coordinate of the end point of the line segment.
     *
     * @serial
     * @since 1.2
     */
    public float x2;

    /**
     * The Y coordinate of the end point of the line segment.
     *
     * @serial
     * @since 1.2
     */
    public float y2;

    /**
     * Constructs and initializes a Line with coordinates (0, 0) &rarr; (0, 0).
     *
     * @since 1.2
     */
    public Float() {
    }

    /**
     * Constructs and initializes a Line from the specified coordinates.
     *
     * @param x1 the X coordinate of the start point
     * @param y1 the Y coordinate of the start point
     * @param x2 the X coordinate of the end point
     * @param y2 the Y coordinate of the end point
     * @since 1.2
     */
    public Float(float x1, float y1, float x2, float y2) {
      setLine(x1, y1, x2, y2);
    }

    /**
     * Constructs and initializes a <code>Line2D</code> from the
     * specified <code>Point2D</code> objects.
     *
     * @param p1 the start <code>Point2D</code> of this line segment
     * @param p2 the end <code>Point2D</code> of this line segment
     * @since 1.2
     */
    public Float(Point2D p1, Point2D p2) {
      setLine(p1, p2);
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.2
     */
    public double getX1() {
      return (double) x1;
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.2
     */
    public double getY1() {
      return (double) y1;
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.2
     */
    public Point2D getP1() {
      return new Point2D.Float(x1, y1);
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.2
     */
    public double getX2() {
      return (double) x2;
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.2
     */
    public double getY2() {
      return (double) y2;
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.2
     */
    public Point2D getP2() {
      return new Point2D.Float(x2, y2);
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.2
     */
    public void setLine(double x1, double y1, double x2, double y2) {
      this.x1 = (float) x1;
      this.y1 = (float) y1;
      this.x2 = (float) x2;
      this.y2 = (float) y2;
    }

    /**
     * Sets the location of the end points of this <code>Line2D</code>
     * to the specified float coordinates.
     *
     * @param x1 the X coordinate of the start point
     * @param y1 the Y coordinate of the start point
     * @param x2 the X coordinate of the end point
     * @param y2 the Y coordinate of the end point
     * @since 1.2
     */
    public void setLine(float x1, float y1, float x2, float y2) {
      this.x1 = x1;
      this.y1 = y1;
      this.x2 = x2;
      this.y2 = y2;
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.2
     */
    public Rectangle2D getBounds2D() {
      float x, y, w, h;
      if (x1 < x2) {
        x = x1;
        w = x2 - x1;
      } else {
        x = x2;
        w = x1 - x2;
      }
      if (y1 < y2) {
        y = y1;
        h = y2 - y1;
      } else {
        y = y2;
        h = y1 - y2;
      }
      return new Rectangle2D.Float(x, y, w, h);
    }

    /*
     * JDK 1.6 serialVersionUID
     */
    private static final long serialVersionUID = 6161772511649436349L;
  }

  /**
   * A line segment specified with double coordinates.
   *
   * @since 1.2
   */
  public static class Double extends Line2D implements Serializable {

    /**
     * The X coordinate of the start point of the line segment.
     *
     * @serial
     * @since 1.2
     */
    public double x1;

    /**
     * The Y coordinate of the start point of the line segment.
     *
     * @serial
     * @since 1.2
     */
    public double y1;

    /**
     * The X coordinate of the end point of the line segment.
     *
     * @serial
     * @since 1.2
     */
    public double x2;

    /**
     * The Y coordinate of the end point of the line segment.
     *
     * @serial
     * @since 1.2
     */
    public double y2;

    /**
     * Constructs and initializes a Line with coordinates (0, 0) &rarr; (0, 0).
     *
     * @since 1.2
     */
    public Double() {
    }

    /**
     * Constructs and initializes a <code>Line2D</code> from the
     * specified coordinates.
     *
     * @param x1 the X coordinate of the start point
     * @param y1 the Y coordinate of the start point
     * @param x2 the X coordinate of the end point
     * @param y2 the Y coordinate of the end point
     * @since 1.2
     */
    public Double(double x1, double y1, double x2, double y2) {
      setLine(x1, y1, x2, y2);
    }

    /**
     * Constructs and initializes a <code>Line2D</code> from the
     * specified <code>Point2D</code> objects.
     *
     * @param p1 the start <code>Point2D</code> of this line segment
     * @param p2 the end <code>Point2D</code> of this line segment
     * @since 1.2
     */
    public Double(Point2D p1, Point2D p2) {
      setLine(p1, p2);
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.2
     */
    public double getX1() {
      return x1;
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.2
     */
    public double getY1() {
      return y1;
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.2
     */
    public Point2D getP1() {
      return new Point2D.Double(x1, y1);
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.2
     */
    public double getX2() {
      return x2;
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.2
     */
    public double getY2() {
      return y2;
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.2
     */
    public Point2D getP2() {
      return new Point2D.Double(x2, y2);
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.2
     */
    public void setLine(double x1, double y1, double x2, double y2) {
      this.x1 = x1;
      this.y1 = y1;
      this.x2 = x2;
      this.y2 = y2;
    }

    /**
     * {@inheritDoc}
     *
     * @since 1.2
     */
    public Rectangle2D getBounds2D() {
      double x, y, w, h;
      if (x1 < x2) {
        x = x1;
        w = x2 - x1;
      } else {
        x = x2;
        w = x1 - x2;
      }
      if (y1 < y2) {
        y = y1;
        h = y2 - y1;
      } else {
        y = y2;
        h = y1 - y2;
      }
      return new Rectangle2D.Double(x, y, w, h);
    }

    /*
     * JDK 1.6 serialVersionUID
     */
    private static final long serialVersionUID = 7979627399746467499L;
  }

  /**
   * This is an abstract class that cannot be instantiated directly.
   * Type-specific implementation subclasses are available for
   * instantiation and provide a number of formats for storing
   * the information necessary to satisfy the various accessory
   * methods below.
   *
   * @see java.awt.geom.Line2D.Float
   * @see java.awt.geom.Line2D.Double
   * @since 1.2
   */
  protected Line2D() {
  }

  /**
   * Returns the X coordinate of the start point in double precision.
   *
   * @return the X coordinate of the start point of this {@code Line2D} object.
   * @since 1.2
   */
  public abstract double getX1();

  /**
   * Returns the Y coordinate of the start point in double precision.
   *
   * @return the Y coordinate of the start point of this {@code Line2D} object.
   * @since 1.2
   */
  public abstract double getY1();

  /**
   * Returns the start <code>Point2D</code> of this <code>Line2D</code>.
   *
   * @return the start <code>Point2D</code> of this <code>Line2D</code>.
   * @since 1.2
   */
  public abstract Point2D getP1();

  /**
   * Returns the X coordinate of the end point in double precision.
   *
   * @return the X coordinate of the end point of this {@code Line2D} object.
   * @since 1.2
   */
  public abstract double getX2();

  /**
   * Returns the Y coordinate of the end point in double precision.
   *
   * @return the Y coordinate of the end point of this {@code Line2D} object.
   * @since 1.2
   */
  public abstract double getY2();

  /**
   * Returns the end <code>Point2D</code> of this <code>Line2D</code>.
   *
   * @return the end <code>Point2D</code> of this <code>Line2D</code>.
   * @since 1.2
   */
  public abstract Point2D getP2();

  /**
   * Sets the location of the end points of this <code>Line2D</code> to
   * the specified double coordinates.
   *
   * @param x1 the X coordinate of the start point
   * @param y1 the Y coordinate of the start point
   * @param x2 the X coordinate of the end point
   * @param y2 the Y coordinate of the end point
   * @since 1.2
   */
  public abstract void setLine(double x1, double y1, double x2, double y2);

  /**
   * Sets the location of the end points of this <code>Line2D</code> to
   * the specified <code>Point2D</code> coordinates.
   *
   * @param p1 the start <code>Point2D</code> of the line segment
   * @param p2 the end <code>Point2D</code> of the line segment
   * @since 1.2
   */
  public void setLine(Point2D p1, Point2D p2) {
    setLine(p1.getX(), p1.getY(), p2.getX(), p2.getY());
  }

  /**
   * Sets the location of the end points of this <code>Line2D</code> to
   * the same as those end points of the specified <code>Line2D</code>.
   *
   * @param l the specified <code>Line2D</code>
   * @since 1.2
   */
  public void setLine(Line2D l) {
    setLine(l.getX1(), l.getY1(), l.getX2(), l.getY2());
  }

  /**
   * Returns an indicator of where the specified point
   * {@code (px,py)} lies with respect to the line segment from
   * {@code (x1,y1)} to {@code (x2,y2)}.
   * The return value can be either 1, -1, or 0 and indicates
   * in which direction the specified line must pivot around its
   * first end point, {@code (x1,y1)}, in order to point at the
   * specified point {@code (px,py)}.
   * <p>A return value of 1 indicates that the line segment must
   * turn in the direction that takes the positive X axis towards
   * the negative Y axis.  In the default coordinate system used by
   * Java 2D, this direction is counterclockwise.
   * <p>A return value of -1 indicates that the line segment must
   * turn in the direction that takes the positive X axis towards
   * the positive Y axis.  In the default coordinate system, this
   * direction is clockwise.
   * <p>A return value of 0 indicates that the point lies
   * exactly on the line segment.  Note that an indicator value
   * of 0 is rare and not useful for determining collinearity
   * because of floating point rounding issues.
   * <p>If the point is colinear with the line segment, but
   * not between the end points, then the value will be -1 if the point
   * lies "beyond {@code (x1,y1)}" or 1 if the point lies
   * "beyond {@code (x2,y2)}".
   *
   * @param x1 the X coordinate of the start point of the specified line segment
   * @param y1 the Y coordinate of the start point of the specified line segment
   * @param x2 the X coordinate of the end point of the specified line segment
   * @param y2 the Y coordinate of the end point of the specified line segment
   * @param px the X coordinate of the specified point to be compared with the specified line
   * segment
   * @param py the Y coordinate of the specified point to be compared with the specified line
   * segment
   * @return an integer that indicates the position of the third specified coordinates with respect
   * to the line segment formed by the first two specified coordinates.
   * @since 1.2
   */
  public static int relativeCCW(double x1, double y1,
      double x2, double y2,
      double px, double py) {
    x2 -= x1;
    y2 -= y1;
    px -= x1;
    py -= y1;
    double ccw = px * y2 - py * x2;
    if (ccw == 0.0) {
      // The point is colinear, classify based on which side of
      // the segment the point falls on.  We can calculate a
      // relative value using the projection of px,py onto the
      // segment - a negative value indicates the point projects
      // outside of the segment in the direction of the particular
      // endpoint used as the origin for the projection.
      ccw = px * x2 + py * y2;
      if (ccw > 0.0) {
        // Reverse the projection to be relative to the original x2,y2
        // x2 and y2 are simply negated.
        // px and py need to have (x2 - x1) or (y2 - y1) subtracted
        //    from them (based on the original values)
        // Since we really want to get a positive answer when the
        //    point is "beyond (x2,y2)", then we want to calculate
        //    the inverse anyway - thus we leave x2 & y2 negated.
        px -= x2;
        py -= y2;
        ccw = px * x2 + py * y2;
        if (ccw < 0.0) {
          ccw = 0.0;
        }
      }
    }
    return (ccw < 0.0) ? -1 : ((ccw > 0.0) ? 1 : 0);
  }

  /**
   * Returns an indicator of where the specified point
   * {@code (px,py)} lies with respect to this line segment.
   * See the method comments of
   * {@link #relativeCCW(double, double, double, double, double, double)}
   * to interpret the return value.
   *
   * @param px the X coordinate of the specified point to be compared with this <code>Line2D</code>
   * @param py the Y coordinate of the specified point to be compared with this <code>Line2D</code>
   * @return an integer that indicates the position of the specified coordinates with respect to
   * this <code>Line2D</code>
   * @see #relativeCCW(double, double, double, double, double, double)
   * @since 1.2
   */
  public int relativeCCW(double px, double py) {
    return relativeCCW(getX1(), getY1(), getX2(), getY2(), px, py);
  }

  /**
   * Returns an indicator of where the specified <code>Point2D</code>
   * lies with respect to this line segment.
   * See the method comments of
   * {@link #relativeCCW(double, double, double, double, double, double)}
   * to interpret the return value.
   *
   * @param p the specified <code>Point2D</code> to be compared with this <code>Line2D</code>
   * @return an integer that indicates the position of the specified <code>Point2D</code> with
   * respect to this <code>Line2D</code>
   * @see #relativeCCW(double, double, double, double, double, double)
   * @since 1.2
   */
  public int relativeCCW(Point2D p) {
    return relativeCCW(getX1(), getY1(), getX2(), getY2(),
        p.getX(), p.getY());
  }

  /**
   * Tests if the line segment from {@code (x1,y1)} to
   * {@code (x2,y2)} intersects the line segment from {@code (x3,y3)}
   * to {@code (x4,y4)}.
   *
   * @param x1 the X coordinate of the start point of the first specified line segment
   * @param y1 the Y coordinate of the start point of the first specified line segment
   * @param x2 the X coordinate of the end point of the first specified line segment
   * @param y2 the Y coordinate of the end point of the first specified line segment
   * @param x3 the X coordinate of the start point of the second specified line segment
   * @param y3 the Y coordinate of the start point of the second specified line segment
   * @param x4 the X coordinate of the end point of the second specified line segment
   * @param y4 the Y coordinate of the end point of the second specified line segment
   * @return <code>true</code> if the first specified line segment and the second specified line
   * segment intersect each other; <code>false</code> otherwise.
   * @since 1.2
   */
  public static boolean linesIntersect(double x1, double y1,
      double x2, double y2,
      double x3, double y3,
      double x4, double y4) {
    return ((relativeCCW(x1, y1, x2, y2, x3, y3) *
        relativeCCW(x1, y1, x2, y2, x4, y4) <= 0)
        && (relativeCCW(x3, y3, x4, y4, x1, y1) *
        relativeCCW(x3, y3, x4, y4, x2, y2) <= 0));
  }

  /**
   * Tests if the line segment from {@code (x1,y1)} to
   * {@code (x2,y2)} intersects this line segment.
   *
   * @param x1 the X coordinate of the start point of the specified line segment
   * @param y1 the Y coordinate of the start point of the specified line segment
   * @param x2 the X coordinate of the end point of the specified line segment
   * @param y2 the Y coordinate of the end point of the specified line segment
   * @return {@code <true>} if this line segment and the specified line segment intersect each
   * other; <code>false</code> otherwise.
   * @since 1.2
   */
  public boolean intersectsLine(double x1, double y1, double x2, double y2) {
    return linesIntersect(x1, y1, x2, y2,
        getX1(), getY1(), getX2(), getY2());
  }

  /**
   * Tests if the specified line segment intersects this line segment.
   *
   * @param l the specified <code>Line2D</code>
   * @return <code>true</code> if this line segment and the specified line segment intersect each
   * other; <code>false</code> otherwise.
   * @since 1.2
   */
  public boolean intersectsLine(Line2D l) {
    return linesIntersect(l.getX1(), l.getY1(), l.getX2(), l.getY2(),
        getX1(), getY1(), getX2(), getY2());
  }

  /**
   * Returns the square of the distance from a point to a line segment.
   * The distance measured is the distance between the specified
   * point and the closest point between the specified end points.
   * If the specified point intersects the line segment in between the
   * end points, this method returns 0.0.
   *
   * @param x1 the X coordinate of the start point of the specified line segment
   * @param y1 the Y coordinate of the start point of the specified line segment
   * @param x2 the X coordinate of the end point of the specified line segment
   * @param y2 the Y coordinate of the end point of the specified line segment
   * @param px the X coordinate of the specified point being measured against the specified line
   * segment
   * @param py the Y coordinate of the specified point being measured against the specified line
   * segment
   * @return a double value that is the square of the distance from the specified point to the
   * specified line segment.
   * @see #ptLineDistSq(double, double, double, double, double, double)
   * @since 1.2
   */
  public static double ptSegDistSq(double x1, double y1,
      double x2, double y2,
      double px, double py) {
    // Adjust vectors relative to x1,y1
    // x2,y2 becomes relative vector from x1,y1 to end of segment
    x2 -= x1;
    y2 -= y1;
    // px,py becomes relative vector from x1,y1 to test point
    px -= x1;
    py -= y1;
    double dotprod = px * x2 + py * y2;
    double projlenSq;
    if (dotprod <= 0.0) {
      // px,py is on the side of x1,y1 away from x2,y2
      // distance to segment is length of px,py vector
      // "length of its (clipped) projection" is now 0.0
      projlenSq = 0.0;
    } else {
      // switch to backwards vectors relative to x2,y2
      // x2,y2 are already the negative of x1,y1=>x2,y2
      // to get px,py to be the negative of px,py=>x2,y2
      // the dot product of two negated vectors is the same
      // as the dot product of the two normal vectors
      px = x2 - px;
      py = y2 - py;
      dotprod = px * x2 + py * y2;
      if (dotprod <= 0.0) {
        // px,py is on the side of x2,y2 away from x1,y1
        // distance to segment is length of (backwards) px,py vector
        // "length of its (clipped) projection" is now 0.0
        projlenSq = 0.0;
      } else {
        // px,py is between x1,y1 and x2,y2
        // dotprod is the length of the px,py vector
        // projected on the x2,y2=>x1,y1 vector times the
        // length of the x2,y2=>x1,y1 vector
        projlenSq = dotprod * dotprod / (x2 * x2 + y2 * y2);
      }
    }
    // Distance to line is now the length of the relative point
    // vector minus the length of its projection onto the line
    // (which is zero if the projection falls outside the range
    //  of the line segment).
    double lenSq = px * px + py * py - projlenSq;
    if (lenSq < 0) {
      lenSq = 0;
    }
    return lenSq;
  }

  /**
   * Returns the distance from a point to a line segment.
   * The distance measured is the distance between the specified
   * point and the closest point between the specified end points.
   * If the specified point intersects the line segment in between the
   * end points, this method returns 0.0.
   *
   * @param x1 the X coordinate of the start point of the specified line segment
   * @param y1 the Y coordinate of the start point of the specified line segment
   * @param x2 the X coordinate of the end point of the specified line segment
   * @param y2 the Y coordinate of the end point of the specified line segment
   * @param px the X coordinate of the specified point being measured against the specified line
   * segment
   * @param py the Y coordinate of the specified point being measured against the specified line
   * segment
   * @return a double value that is the distance from the specified point to the specified line
   * segment.
   * @see #ptLineDist(double, double, double, double, double, double)
   * @since 1.2
   */
  public static double ptSegDist(double x1, double y1,
      double x2, double y2,
      double px, double py) {
    return Math.sqrt(ptSegDistSq(x1, y1, x2, y2, px, py));
  }

  /**
   * Returns the square of the distance from a point to this line segment.
   * The distance measured is the distance between the specified
   * point and the closest point between the current line's end points.
   * If the specified point intersects the line segment in between the
   * end points, this method returns 0.0.
   *
   * @param px the X coordinate of the specified point being measured against this line segment
   * @param py the Y coordinate of the specified point being measured against this line segment
   * @return a double value that is the square of the distance from the specified point to the
   * current line segment.
   * @see #ptLineDistSq(double, double)
   * @since 1.2
   */
  public double ptSegDistSq(double px, double py) {
    return ptSegDistSq(getX1(), getY1(), getX2(), getY2(), px, py);
  }

  /**
   * Returns the square of the distance from a <code>Point2D</code> to
   * this line segment.
   * The distance measured is the distance between the specified
   * point and the closest point between the current line's end points.
   * If the specified point intersects the line segment in between the
   * end points, this method returns 0.0.
   *
   * @param pt the specified <code>Point2D</code> being measured against this line segment.
   * @return a double value that is the square of the distance from the specified
   * <code>Point2D</code> to the current line segment.
   * @see #ptLineDistSq(Point2D)
   * @since 1.2
   */
  public double ptSegDistSq(Point2D pt) {
    return ptSegDistSq(getX1(), getY1(), getX2(), getY2(),
        pt.getX(), pt.getY());
  }

  /**
   * Returns the distance from a point to this line segment.
   * The distance measured is the distance between the specified
   * point and the closest point between the current line's end points.
   * If the specified point intersects the line segment in between the
   * end points, this method returns 0.0.
   *
   * @param px the X coordinate of the specified point being measured against this line segment
   * @param py the Y coordinate of the specified point being measured against this line segment
   * @return a double value that is the distance from the specified point to the current line
   * segment.
   * @see #ptLineDist(double, double)
   * @since 1.2
   */
  public double ptSegDist(double px, double py) {
    return ptSegDist(getX1(), getY1(), getX2(), getY2(), px, py);
  }

  /**
   * Returns the distance from a <code>Point2D</code> to this line
   * segment.
   * The distance measured is the distance between the specified
   * point and the closest point between the current line's end points.
   * If the specified point intersects the line segment in between the
   * end points, this method returns 0.0.
   *
   * @param pt the specified <code>Point2D</code> being measured against this line segment
   * @return a double value that is the distance from the specified <code>Point2D</code> to the
   * current line segment.
   * @see #ptLineDist(Point2D)
   * @since 1.2
   */
  public double ptSegDist(Point2D pt) {
    return ptSegDist(getX1(), getY1(), getX2(), getY2(),
        pt.getX(), pt.getY());
  }

  /**
   * Returns the square of the distance from a point to a line.
   * The distance measured is the distance between the specified
   * point and the closest point on the infinitely-extended line
   * defined by the specified coordinates.  If the specified point
   * intersects the line, this method returns 0.0.
   *
   * @param x1 the X coordinate of the start point of the specified line
   * @param y1 the Y coordinate of the start point of the specified line
   * @param x2 the X coordinate of the end point of the specified line
   * @param y2 the Y coordinate of the end point of the specified line
   * @param px the X coordinate of the specified point being measured against the specified line
   * @param py the Y coordinate of the specified point being measured against the specified line
   * @return a double value that is the square of the distance from the specified point to the
   * specified line.
   * @see #ptSegDistSq(double, double, double, double, double, double)
   * @since 1.2
   */
  public static double ptLineDistSq(double x1, double y1,
      double x2, double y2,
      double px, double py) {
    // Adjust vectors relative to x1,y1
    // x2,y2 becomes relative vector from x1,y1 to end of segment
    x2 -= x1;
    y2 -= y1;
    // px,py becomes relative vector from x1,y1 to test point
    px -= x1;
    py -= y1;
    double dotprod = px * x2 + py * y2;
    // dotprod is the length of the px,py vector
    // projected on the x1,y1=>x2,y2 vector times the
    // length of the x1,y1=>x2,y2 vector
    double projlenSq = dotprod * dotprod / (x2 * x2 + y2 * y2);
    // Distance to line is now the length of the relative point
    // vector minus the length of its projection onto the line
    double lenSq = px * px + py * py - projlenSq;
    if (lenSq < 0) {
      lenSq = 0;
    }
    return lenSq;
  }

  /**
   * Returns the distance from a point to a line.
   * The distance measured is the distance between the specified
   * point and the closest point on the infinitely-extended line
   * defined by the specified coordinates.  If the specified point
   * intersects the line, this method returns 0.0.
   *
   * @param x1 the X coordinate of the start point of the specified line
   * @param y1 the Y coordinate of the start point of the specified line
   * @param x2 the X coordinate of the end point of the specified line
   * @param y2 the Y coordinate of the end point of the specified line
   * @param px the X coordinate of the specified point being measured against the specified line
   * @param py the Y coordinate of the specified point being measured against the specified line
   * @return a double value that is the distance from the specified point to the specified line.
   * @see #ptSegDist(double, double, double, double, double, double)
   * @since 1.2
   */
  public static double ptLineDist(double x1, double y1,
      double x2, double y2,
      double px, double py) {
    return Math.sqrt(ptLineDistSq(x1, y1, x2, y2, px, py));
  }

  /**
   * Returns the square of the distance from a point to this line.
   * The distance measured is the distance between the specified
   * point and the closest point on the infinitely-extended line
   * defined by this <code>Line2D</code>.  If the specified point
   * intersects the line, this method returns 0.0.
   *
   * @param px the X coordinate of the specified point being measured against this line
   * @param py the Y coordinate of the specified point being measured against this line
   * @return a double value that is the square of the distance from a specified point to the current
   * line.
   * @see #ptSegDistSq(double, double)
   * @since 1.2
   */
  public double ptLineDistSq(double px, double py) {
    return ptLineDistSq(getX1(), getY1(), getX2(), getY2(), px, py);
  }

  /**
   * Returns the square of the distance from a specified
   * <code>Point2D</code> to this line.
   * The distance measured is the distance between the specified
   * point and the closest point on the infinitely-extended line
   * defined by this <code>Line2D</code>.  If the specified point
   * intersects the line, this method returns 0.0.
   *
   * @param pt the specified <code>Point2D</code> being measured against this line
   * @return a double value that is the square of the distance from a specified <code>Point2D</code>
   * to the current line.
   * @see #ptSegDistSq(Point2D)
   * @since 1.2
   */
  public double ptLineDistSq(Point2D pt) {
    return ptLineDistSq(getX1(), getY1(), getX2(), getY2(),
        pt.getX(), pt.getY());
  }

  /**
   * Returns the distance from a point to this line.
   * The distance measured is the distance between the specified
   * point and the closest point on the infinitely-extended line
   * defined by this <code>Line2D</code>.  If the specified point
   * intersects the line, this method returns 0.0.
   *
   * @param px the X coordinate of the specified point being measured against this line
   * @param py the Y coordinate of the specified point being measured against this line
   * @return a double value that is the distance from a specified point to the current line.
   * @see #ptSegDist(double, double)
   * @since 1.2
   */
  public double ptLineDist(double px, double py) {
    return ptLineDist(getX1(), getY1(), getX2(), getY2(), px, py);
  }

  /**
   * Returns the distance from a <code>Point2D</code> to this line.
   * The distance measured is the distance between the specified
   * point and the closest point on the infinitely-extended line
   * defined by this <code>Line2D</code>.  If the specified point
   * intersects the line, this method returns 0.0.
   *
   * @param pt the specified <code>Point2D</code> being measured
   * @return a double value that is the distance from a specified <code>Point2D</code> to the
   * current line.
   * @see #ptSegDist(Point2D)
   * @since 1.2
   */
  public double ptLineDist(Point2D pt) {
    return ptLineDist(getX1(), getY1(), getX2(), getY2(),
        pt.getX(), pt.getY());
  }

  /**
   * Tests if a specified coordinate is inside the boundary of this
   * <code>Line2D</code>.  This method is required to implement the
   * {@link Shape} interface, but in the case of <code>Line2D</code>
   * objects it always returns <code>false</code> since a line contains
   * no area.
   *
   * @param x the X coordinate of the specified point to be tested
   * @param y the Y coordinate of the specified point to be tested
   * @return <code>false</code> because a <code>Line2D</code> contains no area.
   * @since 1.2
   */
  public boolean contains(double x, double y) {
    return false;
  }

  /**
   * Tests if a given <code>Point2D</code> is inside the boundary of
   * this <code>Line2D</code>.
   * This method is required to implement the {@link Shape} interface,
   * but in the case of <code>Line2D</code> objects it always returns
   * <code>false</code> since a line contains no area.
   *
   * @param p the specified <code>Point2D</code> to be tested
   * @return <code>false</code> because a <code>Line2D</code> contains no area.
   * @since 1.2
   */
  public boolean contains(Point2D p) {
    return false;
  }

  /**
   * {@inheritDoc}
   *
   * @since 1.2
   */
  public boolean intersects(double x, double y, double w, double h) {
    return intersects(new Rectangle2D.Double(x, y, w, h));
  }

  /**
   * {@inheritDoc}
   *
   * @since 1.2
   */
  public boolean intersects(Rectangle2D r) {
    return r.intersectsLine(getX1(), getY1(), getX2(), getY2());
  }

  /**
   * Tests if the interior of this <code>Line2D</code> entirely contains
   * the specified set of rectangular coordinates.
   * This method is required to implement the <code>Shape</code> interface,
   * but in the case of <code>Line2D</code> objects it always returns
   * false since a line contains no area.
   *
   * @param x the X coordinate of the upper-left corner of the specified rectangular area
   * @param y the Y coordinate of the upper-left corner of the specified rectangular area
   * @param w the width of the specified rectangular area
   * @param h the height of the specified rectangular area
   * @return <code>false</code> because a <code>Line2D</code> contains no area.
   * @since 1.2
   */
  public boolean contains(double x, double y, double w, double h) {
    return false;
  }

  /**
   * Tests if the interior of this <code>Line2D</code> entirely contains
   * the specified <code>Rectangle2D</code>.
   * This method is required to implement the <code>Shape</code> interface,
   * but in the case of <code>Line2D</code> objects it always returns
   * <code>false</code> since a line contains no area.
   *
   * @param r the specified <code>Rectangle2D</code> to be tested
   * @return <code>false</code> because a <code>Line2D</code> contains no area.
   * @since 1.2
   */
  public boolean contains(Rectangle2D r) {
    return false;
  }

  /**
   * {@inheritDoc}
   *
   * @since 1.2
   */
  public Rectangle getBounds() {
    return getBounds2D().getBounds();
  }

  /**
   * Returns an iteration object that defines the boundary of this
   * <code>Line2D</code>.
   * The iterator for this class is not multi-threaded safe,
   * which means that this <code>Line2D</code> class does not
   * guarantee that modifications to the geometry of this
   * <code>Line2D</code> object do not affect any iterations of that
   * geometry that are already in process.
   *
   * @param at the specified {@link AffineTransform}
   * @return a {@link PathIterator} that defines the boundary of this <code>Line2D</code>.
   * @since 1.2
   */
  public PathIterator getPathIterator(AffineTransform at) {
    return new LineIterator(this, at);
  }

  /**
   * Returns an iteration object that defines the boundary of this
   * flattened <code>Line2D</code>.
   * The iterator for this class is not multi-threaded safe,
   * which means that this <code>Line2D</code> class does not
   * guarantee that modifications to the geometry of this
   * <code>Line2D</code> object do not affect any iterations of that
   * geometry that are already in process.
   *
   * @param at the specified <code>AffineTransform</code>
   * @param flatness the maximum amount that the control points for a given curve can vary from
   * colinear before a subdivided curve is replaced by a straight line connecting the end points.
   * Since a <code>Line2D</code> object is always flat, this parameter is ignored.
   * @return a <code>PathIterator</code> that defines the boundary of the flattened
   * <code>Line2D</code>
   * @since 1.2
   */
  public PathIterator getPathIterator(AffineTransform at, double flatness) {
    return new LineIterator(this, at);
  }

  /**
   * Creates a new object of the same class as this object.
   *
   * @return a clone of this instance.
   * @throws OutOfMemoryError if there is not enough memory.
   * @see java.lang.Cloneable
   * @since 1.2
   */
  public Object clone() {
    try {
      return super.clone();
    } catch (CloneNotSupportedException e) {
      // this shouldn't happen, since we are Cloneable
      throw new InternalError(e);
    }
  }
}
